#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
生成测试记录模板 - 独立命令行版本
功能: 将Excel中的多级标题数据导出为Word测试文档
作者: 小李
版本: v1.0.0 (独立版)
使用方式: 直接运行此脚本，根据提示输入参数即可

依赖库安装:
pip install openpyxl python-docx lxml
"""

import os
import sys
import logging
import copy
from typing import List, Dict, Optional

# 导入第三方库
try:
    from openpyxl import load_workbook
    from openpyxl.utils.exceptions import InvalidFileException
except ImportError:
    print("错误: 缺少 openpyxl 库")
    print("请运行: pip install openpyxl")
    sys.exit(1)

try:
    from docx import Document
    from docx.shared import Pt
    from docx.opc.exceptions import PackageNotFoundError
except ImportError:
    print("错误: 缺少 python-docx 库")
    print("请运行: pip install python-docx")
    sys.exit(1)

try:
    from docx.oxml import parse_xml
    from lxml import etree
except ImportError:
    print("错误: 缺少 lxml 库")
    print("请运行: pip install lxml")
    sys.exit(1)


# ============================================================================
#                        Excel到Word导出器类
# ============================================================================

class ExcelToWordExporter:
    """
    Excel到Word文档的导出器
    
    功能：
    - 读取Excel中的多级标题数据
    - 自动添加固定的一级标题"功能测试记录"
    - 生成多级标题结构（Excel层级+1）
    - 使用Word模板保留格式
    - 自动填充父级标题路径和当前标题
    """
    
    # 常量定义
    MAX_SUPPORTED_LEVELS = 9  # 最大支持的层级数
    MIN_TABLE_ROWS = 4  # 模板表格最小行数
    MIN_TABLE_COLS = 2  # 模板表格最小列数
    FIXED_TITLE = "功能测试记录"  # 固定的一级标题
    PARENT_PATH_ROW = 1  # 父级路径填充位置（第2行，索引为1）
    CURRENT_TITLE_ROW = 3  # 当前标题填充位置（第4行，索引为3）
    FILL_COLUMN = 1  # 填充列（第2列，索引为1）

    def __init__(self, verbose=False):
        """
        初始化导出器
        
        Args:
            verbose: 是否显示详细日志
        """
        self.max_level = 0
        self.template_doc = None
        self.template_table = None
        self.success_count = 0
        self.fail_count = 0
        self.verbose = verbose
        
        # 设置日志
        self.logger = logging.getLogger(__name__)
        if not verbose:
            self.logger.setLevel(logging.WARNING)
    
    @staticmethod
    def column_letter_to_number(column: str) -> int:
        """
        将Excel列字母转换为数字（A=1, B=2, ..., Z=26, AA=27, ...）
        
        Args:
            column: Excel列字母（如 'A', 'B', 'AA'）
            
        Returns:
            int: 列数字（从1开始）
        """
        column = column.upper().strip()
        result = 0
        for char in column:
            if not 'A' <= char <= 'Z':
                raise ValueError(f"无效的列字母: {column}")
            result = result * 26 + (ord(char) - ord('A') + 1)
        return result
    
    @staticmethod
    def column_number_to_letter(number: int) -> str:
        """
        将列数字转换为Excel列字母（1=A, 2=B, ..., 26=Z, 27=AA, ...）
        
        Args:
            number: 列数字（从1开始）
            
        Returns:
            str: Excel列字母
        """
        if number < 1:
            raise ValueError(f"列数字必须大于0: {number}")
        
        column = ''
        while number > 0:
            remainder = (number - 1) % 26
            column = chr(ord('A') + remainder) + column
            number = (number - 1) // 26
        return column
        
    def load_template(self, template_path: str) -> bool:
        """
        加载Word模板文档并验证
        
        Args:
            template_path: 模板文档路径
            
        Returns:
            bool: 是否加载成功
        """
        try:
            # 参数验证
            if not template_path or not isinstance(template_path, str):
                self.logger.error("模板路径无效")
                return False
            
            # 文件存在性检查
            if not os.path.exists(template_path):
                self.logger.error(f"模板文件不存在: {template_path}")
                return False
            
            # 文件可读性检查
            if not os.access(template_path, os.R_OK):
                self.logger.error(f"模板文件无法读取: {template_path}")
                return False
                
            # 加载Word文档
            self.template_doc = Document(template_path)
            
            # 验证模板表格数量
            if len(self.template_doc.tables) != 1:
                self.logger.error(f"模板文档需要且只能有一张表格，当前有 {len(self.template_doc.tables)} 张")
                return False
            
            self.template_table = self.template_doc.tables[0]
            
            # 验证表格尺寸
            if len(self.template_table.rows) < self.MIN_TABLE_ROWS:
                self.logger.error(f"模板表格行数不足，至少需要 {self.MIN_TABLE_ROWS} 行，当前只有 {len(self.template_table.rows)} 行")
                return False
            
            if len(self.template_table.columns) < self.MIN_TABLE_COLS:
                self.logger.error(f"模板表格列数不足，至少需要 {self.MIN_TABLE_COLS} 列，当前只有 {len(self.template_table.columns)} 列")
                return False
            
            return True
            
        except PackageNotFoundError:
            self.logger.error(f"无法打开Word文档，文件可能损坏: {template_path}")
            return False
        except Exception as e:
            self.logger.error(f"加载模板失败: {type(e).__name__} - {e}")
            return False
    
    def export_to_word(self, excel_path: str, output_path: str, 
                      start_row: int, end_row: int,
                      start_col: int, end_col: int,
                      template_path: str) -> Dict[str, any]:
        """
        将Excel数据导出为Word文档
        
        Args:
            excel_path: Excel文件路径
            output_path: 输出Word文件路径
            start_row: 起始行（从1开始）
            end_row: 结束行
            start_col: 起始列（从1开始）
            end_col: 结束列
            template_path: 模板文件路径
            
        Returns:
            dict: 处理结果，包含success、message和details字段
        """
        wb = None
        try:
            # 参数验证
            validation_result = self._validate_parameters(
                excel_path, output_path, start_row, end_row, start_col, end_col
            )
            if not validation_result['valid']:
                return {
                    'success': False,
                    'message': validation_result['message']
                }
            
            # 加载模板
            if not self.load_template(template_path):
                return {
                    'success': False,
                    'message': '模板加载失败'
                }
            
            # 加载Excel文件
            wb = load_workbook(excel_path, data_only=True)
            ws = wb.active
            
            # 验证Excel数据范围
            if end_row > ws.max_row:
                end_row = ws.max_row
            
            if end_col > ws.max_column:
                end_col = ws.max_column
            
            # 推断层级数量
            self.max_level = min(end_col - start_col + 1, self.MAX_SUPPORTED_LEVELS)
            
            # 保存模板表格的深拷贝，然后从模板文档中移除
            template_table_copy = copy.deepcopy(self.template_table._element)
            self.template_doc.tables[0]._element.getparent().remove(self.template_doc.tables[0]._element)
            
            # 使用模板文档作为输出文档（保留所有样式）
            output_doc = self.template_doc
            
            # 重置计数器
            self.success_count = 0
            self.fail_count = 0
            
            # 处理数据
            self._process_excel_data(
                ws, output_doc,
                start_row, end_row,
                start_col, end_col,
                template_table_copy
            )
            
            # 保存文档
            output_dir = os.path.dirname(output_path)
            if output_dir:
                os.makedirs(output_dir, exist_ok=True)
            
            output_doc.save(output_path)
            
            return {
                'success': True,
                'message': '导出成功',
                'details': {
                    'total_levels': self.max_level,
                    'processed_rows': end_row - start_row + 1,
                    'success_count': self.success_count,
                    'fail_count': self.fail_count,
                    'output_file': output_path
                }
            }
            
        except InvalidFileException as e:
            return {
                'success': False,
                'message': f'无效的Excel文件: {str(e)}'
            }
        except PermissionError as e:
            return {
                'success': False,
                'message': f'文件权限错误，无法保存: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'message': f'导出失败: {str(e)}'
            }
        finally:
            # 确保Excel文件被关闭
            if wb is not None:
                try:
                    wb.close()
                except:
                    pass
    
    def _validate_parameters(self, excel_path: str, output_path: str,
                           start_row: int, end_row: int,
                           start_col: int, end_col: int) -> Dict[str, any]:
        """验证输入参数的有效性"""
        # 检查Excel路径
        if not excel_path or not isinstance(excel_path, str):
            return {'valid': False, 'message': 'Excel文件路径无效'}
        
        if not os.path.exists(excel_path):
            return {'valid': False, 'message': f'Excel文件不存在: {excel_path}'}
        
        if not os.access(excel_path, os.R_OK):
            return {'valid': False, 'message': f'Excel文件无法读取: {excel_path}'}
        
        # 检查输出路径
        if not output_path or not isinstance(output_path, str):
            return {'valid': False, 'message': '输出文件路径无效'}
        
        # 检查行列参数
        if not all(isinstance(x, int) for x in [start_row, end_row, start_col, end_col]):
            return {'valid': False, 'message': '行列参数必须为整数'}
        
        if start_row < 1 or start_col < 1:
            return {'valid': False, 'message': '起始行和起始列必须大于0'}
        
        if start_row > end_row:
            return {'valid': False, 'message': f'起始行 ({start_row}) 不能大于结束行 ({end_row})'}
        
        if start_col > end_col:
            return {'valid': False, 'message': f'起始列 ({start_col}) 不能大于结束列 ({end_col})'}
        
        if (end_col - start_col + 1) > self.MAX_SUPPORTED_LEVELS:
            return {'valid': False, 'message': f'层级数量超出限制，最多支持 {self.MAX_SUPPORTED_LEVELS} 级'}
        
        return {'valid': True, 'message': '参数验证通过'}
    
    def _process_excel_data(self, worksheet, doc, 
                           start_row: int, end_row: int,
                           start_col: int, end_col: int,
                           template_table_element):
        """处理Excel数据并生成Word文档"""
        levels = self.max_level
        # 层级+2：索引0保留，索引1是固定标题"功能测试记录"，索引2开始是Excel数据
        current_titles = [""] * (levels + 2)
        
        # 添加固定的一级标题"功能测试记录"
        self._add_heading(doc, self.FIXED_TITLE, 1)
        current_titles[1] = self.FIXED_TITLE
        
        processed_rows = 0
        for row_idx in range(start_row, end_row + 1):
            last_added_level = 0
            
            # 处理每个层级（Excel层级从1开始，但在Word中从2级开始）
            for excel_lvl in range(1, levels + 1):
                col_idx = start_col + excel_lvl - 1
                cell_value = self._get_cell_value(worksheet, row_idx, col_idx)
                
                # Word中的实际层级 = Excel层级 + 1
                word_lvl = excel_lvl + 1
                
                if cell_value:
                    # 检查是否与当前层级标题不同
                    if cell_value != current_titles[word_lvl]:
                        # 更新当前层级标题
                        current_titles[word_lvl] = cell_value
                        
                        # 清空下级标题
                        for k in range(word_lvl + 1, levels + 2):
                            current_titles[k] = ""
                        
                        # 添加标题段落（使用Word层级）
                        self._add_heading(doc, cell_value, word_lvl)
                        
                        # 记录本行最后添加的层级
                        last_added_level = word_lvl
            
            # 在本行最后一个标题后插入表格
            if last_added_level > 0:
                self._insert_table(doc, current_titles, last_added_level, template_table_element)
                processed_rows += 1
    
    def _get_cell_value(self, worksheet, row: int, col: int) -> str:
        """安全地获取并处理单元格值"""
        try:
            cell = worksheet.cell(row, col)
            value = cell.value
            
            # 空值处理
            if value is None:
                return ""
            
            # 转换为字符串并去除首尾空格
            str_val = str(value).strip()
            
            # 过滤斜杠和None字符串（视为空值，表示继承上一行）
            if str_val in ["\\", "/", "None", ""]:
                return ""
            
            return str_val
            
        except:
            return ""
    
    def _add_heading(self, doc, text: str, level: int):
        """添加标题段落并设置样式"""
        if not text:
            return
        
        # 防御性编程：限制层级范围
        level = max(1, min(level, 9))
        
        try:
            p = doc.add_paragraph(text)
            
            # 设置标题样式（尝试多种可能的样式名称）
            try:
                p.style = f'Heading {level}'
            except:
                try:
                    p.style = f'标题 {level}'
                except:
                    # 手动设置样式
                    if p.runs:
                        run = p.runs[0]
                    else:
                        run = p.add_run()
                    
                    # 根据层级设置字体大小
                    run.font.size = Pt(max(10, 16 - level))
                    run.font.bold = True
            
        except Exception as e:
            self.logger.error(f"添加标题失败: {text}, 层级{level}, 错误: {e}")
    
    def _insert_table(self, doc, title_path: List[str], level: int, template_table_element):
        """在标题后插入表格并填充内容"""
        current_title = title_path[level] if level < len(title_path) else ""
        
        if not current_title:
            self.fail_count += 1
            return
        
        try:
            # 克隆模板表格（保留命名空间）
            xml_str = etree.tostring(template_table_element, encoding='unicode')
            new_table_element = parse_xml(xml_str)
            
            # 插入到文档
            if len(doc.paragraphs) > 0:
                last_para = doc.paragraphs[-1]._element
                last_para.addnext(new_table_element)
            else:
                doc._element.body.append(new_table_element)
            
            # 获取刚插入的表格对象
            if len(doc.tables) == 0:
                raise RuntimeError("表格插入失败，文档中没有表格")
            
            table = doc.tables[-1]
            
            # 构建父级标题路径（从索引2开始到level-1，不包含"功能测试记录"）
            if level > 2:
                # 如果层级大于2（即至少是3级标题），包含Excel中的上级标题
                parent_path = "-".join([
                    title_path[i] for i in range(2, level)
                    if i < len(title_path) and title_path[i]
                ])
            else:
                # 如果是2级标题，没有Excel中的上级
                parent_path = "(无上级)"
            
            # 填充表格内容
            if len(table.rows) >= self.MIN_TABLE_ROWS and len(table.columns) >= self.MIN_TABLE_COLS:
                try:
                    # 填充第2行第2列: 父级标题路径
                    cell_2_2 = table.rows[self.PARENT_PATH_ROW].cells[self.FILL_COLUMN]
                    self._fill_cell(cell_2_2, parent_path)
                    
                    # 填充第4行第2列: 当前标题
                    cell_4_2 = table.rows[self.CURRENT_TITLE_ROW].cells[self.FILL_COLUMN]
                    self._fill_cell(cell_4_2, current_title)
                    
                except IndexError:
                    self.fail_count += 1
                    return
            
            self.success_count += 1
            
        except Exception as e:
            self.fail_count += 1
        
        # 添加空行
        try:
            doc.add_paragraph()
        except:
            pass
    
    def _fill_cell(self, cell, text: str):
        """填充单元格文本，保持原有格式"""
        try:
            # 清空所有段落
            for para in cell.paragraphs:
                para.clear()
            
            # 在第一个段落中添加文本
            if cell.paragraphs:
                cell.paragraphs[0].add_run(text)
            else:
                # 如果没有段落，使用简单方式
                cell.text = text
                
        except:
            try:
                cell.text = text
            except:
                pass
    
    def get_excel_info(self, excel_path: str) -> Dict[str, any]:
        """获取Excel文件信息"""
        wb = None
        try:
            # 参数验证
            if not excel_path or not isinstance(excel_path, str):
                return {
                    'success': False,
                    'message': 'Excel文件路径无效'
                }
            
            if not os.path.exists(excel_path):
                return {
                    'success': False,
                    'message': f'Excel文件不存在: {excel_path}'
                }
            
            if not os.access(excel_path, os.R_OK):
                return {
                    'success': False,
                    'message': f'Excel文件无法读取: {excel_path}'
                }
            
            # 加载Excel文件
            wb = load_workbook(excel_path, data_only=True, read_only=True)
            ws = wb.active
            
            # 收集信息
            info = {
                'success': True,
                'sheet_name': ws.title or '未命名',
                'max_row': ws.max_row or 0,
                'max_column': ws.max_column or 0,
                'sheets': wb.sheetnames or [],
                'file_path': excel_path
            }
            
            return info
            
        except InvalidFileException as e:
            return {
                'success': False,
                'message': f'无效的Excel文件格式: {str(e)}'
            }
        except PermissionError as e:
            return {
                'success': False,
                'message': f'文件权限错误，无法访问: {str(e)}'
            }
        except Exception as e:
            return {
                'success': False,
                'message': f'读取Excel失败: {str(e)}'
            }
        finally:
            # 确保文件被关闭
            if wb is not None:
                try:
                    wb.close()
                except:
                    pass


# ============================================================================
#                          命令行交互界面
# ============================================================================

def print_banner():
    """打印欢迎横幅"""
    print("=" * 60)
    print(" " * 15 + "Excel导出Word测试记录工具")
    print(" " * 18 + "命令行版本 v2.0.0")
    print("=" * 60)
    print()


def get_input(prompt: str, default: str = None) -> str:
    """获取用户输入"""
    if default:
        user_input = input(f"{prompt} [默认: {default}]: ").strip()
        return user_input if user_input else default
    else:
        while True:
            user_input = input(f"{prompt}: ").strip()
            if user_input:
                return user_input
            print("  ⚠ 此项为必填项，请输入有效内容")


def get_file_path(prompt: str, must_exist: bool = True) -> str:
    """获取文件路径并验证"""
    while True:
        path = get_input(prompt).replace('"', '').replace("'", '')
        
        if must_exist:
            if not os.path.exists(path):
                print(f"    ✗ 文件不存在: {path}")
                print(f"    请检查路径是否正确，或拖拽文件到命令行窗口")
                continue
            if not os.path.isfile(path):
                print(f"    ✗ 这不是一个文件: {path}")
                continue
        
        return os.path.abspath(path)


def get_integer(prompt: str, min_val: int = None, max_val: int = None, default: int = None) -> int:
    """获取整数输入并验证"""
    while True:
        try:
            if default is not None:
                user_input = input(f"{prompt} [默认: {default}]: ").strip()
                if not user_input:
                    return default
                value = int(user_input)
            else:
                value = int(input(f"{prompt}: ").strip())
            
            if min_val is not None and value < min_val:
                print(f"    ✗ 值不能小于 {min_val}")
                continue
            
            if max_val is not None and value > max_val:
                print(f"    ✗ 值不能大于 {max_val}")
                continue
            
            return value
            
        except ValueError:
            print("    ✗ 请输入有效的整数")


def get_column_input(prompt: str, default_letter: str = None) -> int:
    """获取列输入（支持字母或数字）"""
    while True:
        try:
            if default_letter:
                user_input = input(f"{prompt} [默认: {default_letter}]: ").strip().upper()
                if not user_input:
                    return ExcelToWordExporter.column_letter_to_number(default_letter)
            else:
                user_input = input(f"{prompt}: ").strip().upper()
            
            # 判断是字母还是数字
            if user_input.isalpha():
                # 字母输入
                return ExcelToWordExporter.column_letter_to_number(user_input)
            elif user_input.isdigit():
                # 数字输入
                col_num = int(user_input)
                if col_num < 1:
                    print("    ✗ 列号必须大于0")
                    continue
                return col_num
            else:
                print("    ✗ 请输入列字母（如A、B）或列数字（如1、2）")
                
        except ValueError as e:
            print(f"    ✗ 输入错误: {e}")


def show_excel_info(exporter: ExcelToWordExporter, excel_path: str):
    """显示Excel文件信息"""
    print("\n  正在读取Excel信息...", end='', flush=True)
    info = exporter.get_excel_info(excel_path)
    print("\r  ", end='')  # 清除提示信息
    
    if info['success']:
        print(f"✓ 工作表: {info['sheet_name']}")
        print(f"  ✓ 数据范围: {info['max_row']} 行 × {info['max_column']} 列 (A-{ExcelToWordExporter.column_number_to_letter(info['max_column'])})")
        return info
    else:
        print(f"✗ 读取失败: {info['message']}")
        return None


def main():
    """主函数"""
    print_banner()
    
    try:
        # 创建导出器实例
        exporter = ExcelToWordExporter(verbose=False)
        
        # 1. 获取Excel文件路径
        print("【步骤 1/7】选择Excel文件")
        print("  提示: 可以直接拖拽文件到命令行窗口")
        excel_path = get_file_path("  请输入Excel文件路径", must_exist=True)
        
        # 显示Excel信息
        excel_info = show_excel_info(exporter, excel_path)
        if not excel_info:
            print("\n程序退出")
            return
        
        # 2. 获取Word模板路径
        print("\n【步骤 2/7】选择Word模板文件")
        print("  提示: 模板必须包含一张表格（至少4行2列）")
        
        # 检查是否有默认模板
        default_template = "test_template.docx"
        if os.path.exists(default_template):
            print(f"  提示: 找到默认模板 {default_template}")
            use_default = get_input("  是否使用默认模板? (y/n)", "y").lower()
            if use_default == 'y':
                template_path = default_template
            else:
                template_path = get_file_path("  请输入Word模板文件路径", must_exist=True)
        else:
            template_path = get_file_path("  请输入Word模板文件路径", must_exist=True)
        
        # 3. 获取起始行
        print("\n【步骤 3/7】设置数据范围 - 起始行")
        print(f"  提示: Excel总行数为 {excel_info['max_row']}")
        start_row = get_integer("  请输入起始行号", min_val=1, max_val=excel_info['max_row'], default=1)
        
        # 4. 获取结束行
        print("\n【步骤 4/7】设置数据范围 - 结束行")
        end_row = get_integer("  请输入结束行号", min_val=start_row, max_val=excel_info['max_row'], 
                             default=excel_info['max_row'])
        
        # 5. 获取起始列
        print("\n【步骤 5/7】设置数据范围 - 起始列")
        print(f"  提示: 可以输入列字母(如A、B)或列数字(如1、2)")
        start_col = get_column_input("  请输入起始列", default_letter="A")
        
        # 6. 获取结束列
        print("\n【步骤 6/7】设置数据范围 - 结束列")
        max_end_col = min(start_col + ExcelToWordExporter.MAX_SUPPORTED_LEVELS - 1, excel_info['max_column'])
        default_end_letter = ExcelToWordExporter.column_number_to_letter(max_end_col)
        print(f"  提示: 最多支持 {ExcelToWordExporter.MAX_SUPPORTED_LEVELS} 个层级，基于起始列 {ExcelToWordExporter.column_number_to_letter(start_col)}，建议结束列为 {default_end_letter}")
        end_col = get_column_input("  请输入结束列", default_letter=default_end_letter)
        
        # 验证列范围
        if end_col < start_col:
            print(f"\n✗ 错误: 结束列不能小于起始列")
            return
        
        if (end_col - start_col + 1) > ExcelToWordExporter.MAX_SUPPORTED_LEVELS:
            print(f"\n✗ 错误: 层级数量超出限制，最多支持 {ExcelToWordExporter.MAX_SUPPORTED_LEVELS} 级")
            return
        
        # 7. 获取输出路径
        print("\n【步骤 7/7】设置输出文件")
        default_output = "测试记录模板.docx"
        output_path = get_input("  请输入输出Word文件路径", default_output)
        output_path = os.path.abspath(output_path)
        
        # 确认信息
        print("\n" + "=" * 60)
        print("【参数确认】请仔细核对以下配置")
        print("=" * 60)
        print(f"  📂 Excel文件: {os.path.basename(excel_path)}")
        print(f"  📄 Word模板: {os.path.basename(template_path)}")
        print(f"  📊 数据行范围: {start_row} - {end_row} (共 {end_row - start_row + 1} 行)")
        print(f"  📊 数据列范围: {ExcelToWordExporter.column_number_to_letter(start_col)} - {ExcelToWordExporter.column_number_to_letter(end_col)} (共 {end_col - start_col + 1} 列 / {end_col - start_col + 1} 个层级)")
        print(f"  💾 输出路径: {output_path}")
        print("=" * 60)
        
        confirm = get_input("\n  确认开始处理? (y/n)", "y").lower()
        if confirm != 'y':
            print("\n  已取消操作")
            return
        
        # 执行导出
        print("\n正在处理，请稍候...")
        print("-" * 60)
        
        result = exporter.export_to_word(
            excel_path=excel_path,
            output_path=output_path,
            start_row=start_row,
            end_row=end_row,
            start_col=start_col,
            end_col=end_col,
            template_path=template_path
        )
        
        # 显示结果
        print("-" * 60)
        if result['success']:
            print("\n  ✓ 处理成功！")
            print(f"\n【处理详情】")
            details = result.get('details', {})
            print(f"  • 总层级数: {details.get('total_levels', 0)}")
            print(f"  • 处理行数: {details.get('processed_rows', 0)}")
            print(f"  • 成功插入表格: {details.get('success_count', 0)}")
            if details.get('fail_count', 0) > 0:
                print(f"  • 失败次数: {details.get('fail_count', 0)}")
            print(f"\n  📄 输出文件: {details.get('output_file', output_path)}")
            
            # 询问是否打开文件
            if os.name == 'nt':  # Windows系统
                open_file = get_input("\n  是否打开生成的Word文档? (y/n)", "y").lower()
                if open_file == 'y':
                    print("  正在打开文件...")
                    os.startfile(output_path)
        else:
            print(f"\n  ✗ 处理失败: {result['message']}")
        
    except KeyboardInterrupt:
        print("\n\n  程序已被用户中断")
    except Exception as e:
        print(f"\n  ✗ 发生错误: {type(e).__name__} - {e}")
    finally:
        print("\n" + "=" * 60)
        print(" " * 20 + "感谢使用！")
        print("=" * 60)
        input("\n  按Enter键退出...")


if __name__ == "__main__":
    # 配置日志（仅在详细模式下显示）
    logging.basicConfig(level=logging.WARNING, format='%(message)s')
    main()
